home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / ContainerOrderFocusTraversalPolicy.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  5.3 KB  |  351 lines
  1. package java.awt;
  2.  
  3. import java.io.Serializable;
  4. import java.util.logging.Level;
  5. import java.util.logging.Logger;
  6.  
  7. public class ContainerOrderFocusTraversalPolicy extends FocusTraversalPolicy implements Serializable {
  8.    private static final MutableBoolean found = new MutableBoolean();
  9.    private static final Logger log = Logger.getLogger("java.awt.ContainerOrderFocusTraversalPolicy");
  10.    private static final long serialVersionUID = 486933713763926351L;
  11.    private boolean implicitDownCycleTraversal = true;
  12.  
  13.    public Component getComponentAfter(Container var1, Component var2) {
  14.       if (log.isLoggable(Level.FINE)) {
  15.          log.fine("Looking for next component in " + var1 + " for " + var2);
  16.       }
  17.  
  18.       if (var1 != null && var2 != null) {
  19.          if (!var1.isFocusTraversalPolicyProvider() && !var1.isFocusCycleRoot()) {
  20.             throw new IllegalArgumentException("aContainer should be focus cycle root or focus traversal policy provider");
  21.          } else if (var1.isFocusCycleRoot() && !var2.isFocusCycleRoot(var1)) {
  22.             throw new IllegalArgumentException("aContainer is not a focus cycle root of aComponent");
  23.          } else {
  24.             synchronized(var1.getTreeLock()) {
  25.                found.value = false;
  26.                Component var4 = this.getComponentAfter(var1, var2, found);
  27.                if (var4 != null) {
  28.                   if (log.isLoggable(Level.FINE)) {
  29.                      log.fine("After component is " + var4);
  30.                   }
  31.  
  32.                   return var4;
  33.                } else if (found.value) {
  34.                   if (log.isLoggable(Level.FINE)) {
  35.                      log.fine("Didn't find next component in " + var1 + " - falling back to the first ");
  36.                   }
  37.  
  38.                   return this.getFirstComponent(var1);
  39.                } else {
  40.                   if (log.isLoggable(Level.FINE)) {
  41.                      log.fine("After component is null");
  42.                   }
  43.  
  44.                   return null;
  45.                }
  46.             }
  47.          }
  48.       } else {
  49.          throw new IllegalArgumentException("aContainer and aComponent cannot be null");
  50.       }
  51.    }
  52.  
  53.    private Component getComponentAfter(Container var1, Component var2, MutableBoolean var3) {
  54.       if (var1.isVisible() && var1.isDisplayable()) {
  55.          if (var3.value) {
  56.             if (this.accept(var1)) {
  57.                return var1;
  58.             }
  59.          } else if (var1 == var2) {
  60.             var3.value = true;
  61.          }
  62.  
  63.          for(int var4 = 0; var4 < var1.ncomponents; ++var4) {
  64.             Component var5 = var1.component[var4];
  65.             if (var5 instanceof Container && !((Container)var5).isFocusCycleRoot()) {
  66.                Component var6 = null;
  67.                if (((Container)var5).isFocusTraversalPolicyProvider()) {
  68.                   if (log.isLoggable(Level.FINE)) {
  69.                      log.fine("Entering FTP " + var5);
  70.                   }
  71.  
  72.                   Container var7 = (Container)var5;
  73.                   FocusTraversalPolicy var8 = var7.getFocusTraversalPolicy();
  74.                   if (log.isLoggable(Level.FINE)) {
  75.                      log.fine("FTP contains " + var2 + ": " + var7.isAncestorOf(var2));
  76.                   }
  77.  
  78.                   if (var3.value) {
  79.                      var6 = var8.getDefaultComponent(var7);
  80.                      if (log.isLoggable(Level.FINE)) {
  81.                         log.fine("Used FTP for getting default component: " + var6);
  82.                      }
  83.                   } else {
  84.                      var3.value = var7.isAncestorOf(var2);
  85.                      if (var3.value) {
  86.                         if (var2 == var8.getLastComponent(var7)) {
  87.                            var6 = null;
  88.                         } else {
  89.                            var6 = var8.getComponentAfter(var7, var2);
  90.                            if (log.isLoggable(Level.FINE)) {
  91.                               log.fine("FTP found next for the component : " + var6);
  92.                            }
  93.                         }
  94.                      }
  95.                   }
  96.                } else {
  97.                   var6 = this.getComponentAfter((Container)var5, var2, var3);
  98.                }
  99.  
  100.                if (var6 != null) {
  101.                   return var6;
  102.                }
  103.             } else if (var3.value) {
  104.                if (this.accept(var5)) {
  105.                   return var5;
  106.                }
  107.             } else if (var5 == var2) {
  108.                var3.value = true;
  109.             }
  110.  
  111.             if (var3.value && this.getImplicitDownCycleTraversal() && var5 instanceof Container && ((Container)var5).isFocusCycleRoot()) {
  112.                Container var9 = (Container)var5;
  113.                Component var10 = var9.getFocusTraversalPolicy().getDefaultComponent(var9);
  114.                if (var10 != null) {
  115.                   return var10;
  116.                }
  117.             }
  118.          }
  119.  
  120.          return null;
  121.       } else {
  122.          return null;
  123.       }
  124.    }
  125.  
  126.    public Component getComponentBefore(Container var1, Component var2) {
  127.       if (var1 != null && var2 != null) {
  128.          if (!var1.isFocusTraversalPolicyProvider() && !var1.isFocusCycleRoot()) {
  129.             throw new IllegalArgumentException("aContainer should be focus cycle root or focus traversal policy provider");
  130.          } else if (var1.isFocusCycleRoot() && !var2.isFocusCycleRoot(var1)) {
  131.             throw new IllegalArgumentException("aContainer is not a focus cycle root of aComponent");
  132.          } else {
  133.             synchronized(var1.getTreeLock()) {
  134.                found.value = false;
  135.                Component var4 = this.getComponentBefore(var1, var2, found);
  136.                if (var4 != null) {
  137.                   if (log.isLoggable(Level.FINE)) {
  138.                      log.fine("Before component is " + var4);
  139.                   }
  140.  
  141.                   return var4;
  142.                } else if (found.value) {
  143.                   if (log.isLoggable(Level.FINE)) {
  144.                      log.fine("Didn't find before component in " + var1 + " - falling back to the first ");
  145.                   }
  146.  
  147.                   return this.getLastComponent(var1);
  148.                } else {
  149.                   if (log.isLoggable(Level.FINE)) {
  150.                      log.fine("Before component is null");
  151.                   }
  152.  
  153.                   return null;
  154.                }
  155.             }
  156.          }
  157.       } else {
  158.          throw new IllegalArgumentException("aContainer and aComponent cannot be null");
  159.       }
  160.    }
  161.  
  162.    private Component getComponentBefore(Container var1, Component var2, MutableBoolean var3) {
  163.       if (var1.isVisible() && var1.isDisplayable()) {
  164.          for(int var4 = var1.ncomponents - 1; var4 >= 0; --var4) {
  165.             Component var5 = var1.component[var4];
  166.             if (var5 == var2) {
  167.                var3.value = true;
  168.             } else if (var5 instanceof Container && !((Container)var5).isFocusCycleRoot()) {
  169.                Component var6 = null;
  170.                if (((Container)var5).isFocusTraversalPolicyProvider()) {
  171.                   if (log.isLoggable(Level.FINE)) {
  172.                      log.fine("Entering FTP " + var5);
  173.                   }
  174.  
  175.                   Container var7 = (Container)var5;
  176.                   FocusTraversalPolicy var8 = var7.getFocusTraversalPolicy();
  177.                   if (log.isLoggable(Level.FINE)) {
  178.                      log.fine("FTP contains " + var2 + ": " + var7.isAncestorOf(var2));
  179.                   }
  180.  
  181.                   if (var3.value) {
  182.                      var6 = var8.getLastComponent(var7);
  183.                      if (log.isLoggable(Level.FINE)) {
  184.                         log.fine("Used FTP for getting last component: " + var6);
  185.                      }
  186.                   } else {
  187.                      var3.value = var7.isAncestorOf(var2);
  188.                      if (var3.value) {
  189.                         if (var2 == var8.getFirstComponent(var7)) {
  190.                            var6 = null;
  191.                         } else {
  192.                            var6 = var8.getComponentBefore(var7, var2);
  193.                            if (log.isLoggable(Level.FINE)) {
  194.                               log.fine("FTP found previous for the component : " + var6);
  195.                            }
  196.                         }
  197.                      }
  198.                   }
  199.                } else {
  200.                   var6 = this.getComponentBefore((Container)var5, var2, var3);
  201.                }
  202.  
  203.                if (var6 != null) {
  204.                   return var6;
  205.                }
  206.             } else if (var3.value && this.accept(var5)) {
  207.                return var5;
  208.             }
  209.          }
  210.  
  211.          if (var3.value) {
  212.             if (this.accept(var1)) {
  213.                return var1;
  214.             }
  215.          } else if (var1 == var2) {
  216.             var3.value = true;
  217.          }
  218.  
  219.          return null;
  220.       } else {
  221.          return null;
  222.       }
  223.    }
  224.  
  225.    public Component getFirstComponent(Container var1) {
  226.       if (var1 == null) {
  227.          throw new IllegalArgumentException("aContainer cannot be null");
  228.       } else {
  229.          synchronized(var1.getTreeLock()) {
  230.             if (var1.isVisible() && var1.isDisplayable()) {
  231.                if (this.accept(var1)) {
  232.                   return var1;
  233.                } else {
  234.                   for(int var3 = 0; var3 < var1.ncomponents; ++var3) {
  235.                      Component var4 = var1.component[var3];
  236.                      if (var4 instanceof Container && !((Container)var4).isFocusCycleRoot()) {
  237.                         Object var5 = null;
  238.                         Container var6 = (Container)var4;
  239.                         Component var10;
  240.                         if (var6.isFocusTraversalPolicyProvider()) {
  241.                            FocusTraversalPolicy var7 = var6.getFocusTraversalPolicy();
  242.                            var10 = var7.getDefaultComponent(var6);
  243.                         } else {
  244.                            var10 = this.getFirstComponent((Container)var4);
  245.                         }
  246.  
  247.                         if (var10 != null) {
  248.                            return var10;
  249.                         }
  250.                      } else if (this.accept(var4)) {
  251.                         return var4;
  252.                      }
  253.                   }
  254.  
  255.                   return null;
  256.                }
  257.             } else {
  258.                return null;
  259.             }
  260.          }
  261.       }
  262.    }
  263.  
  264.    public Component getLastComponent(Container var1) {
  265.       if (var1 == null) {
  266.          throw new IllegalArgumentException("aContainer cannot be null");
  267.       } else {
  268.          if (log.isLoggable(Level.FINE)) {
  269.             log.fine("Looking for the last component in " + var1);
  270.          }
  271.  
  272.          synchronized(var1.getTreeLock()) {
  273.             if (var1.isVisible() && var1.isDisplayable()) {
  274.                for(int var3 = var1.ncomponents - 1; var3 >= 0; --var3) {
  275.                   Component var4 = var1.component[var3];
  276.                   if (var4 instanceof Container && !((Container)var4).isFocusCycleRoot()) {
  277.                      Object var5 = null;
  278.                      Container var6 = (Container)var4;
  279.                      Component var10;
  280.                      if (var6.isFocusTraversalPolicyProvider()) {
  281.                         if (log.isLoggable(Level.FINE)) {
  282.                            log.fine("\tEntering FTP " + var6);
  283.                         }
  284.  
  285.                         FocusTraversalPolicy var7 = var6.getFocusTraversalPolicy();
  286.                         var10 = var7.getLastComponent(var6);
  287.                      } else {
  288.                         if (log.isLoggable(Level.FINE)) {
  289.                            log.fine("\tEntering sub-container");
  290.                         }
  291.  
  292.                         var10 = this.getLastComponent((Container)var4);
  293.                      }
  294.  
  295.                      if (var10 != null) {
  296.                         if (log.isLoggable(Level.FINE)) {
  297.                            log.fine("\tFound last component : " + var10);
  298.                         }
  299.  
  300.                         return var10;
  301.                      }
  302.                   } else if (this.accept(var4)) {
  303.                      return var4;
  304.                   }
  305.                }
  306.  
  307.                if (this.accept(var1)) {
  308.                   return var1;
  309.                } else {
  310.                   return null;
  311.                }
  312.             } else {
  313.                return null;
  314.             }
  315.          }
  316.       }
  317.    }
  318.  
  319.    public Component getDefaultComponent(Container var1) {
  320.       return this.getFirstComponent(var1);
  321.    }
  322.  
  323.    public void setImplicitDownCycleTraversal(boolean var1) {
  324.       this.implicitDownCycleTraversal = var1;
  325.    }
  326.  
  327.    public boolean getImplicitDownCycleTraversal() {
  328.       return this.implicitDownCycleTraversal;
  329.    }
  330.  
  331.    protected boolean accept(Component var1) {
  332.       if (var1.isVisible() && var1.isDisplayable() && var1.isFocusable() && var1.isEnabled()) {
  333.          if (!(var1 instanceof Window)) {
  334.             for(Container var2 = var1.getParent(); var2 != null; var2 = var2.getParent()) {
  335.                if (!var2.isEnabled() && !var2.isLightweight()) {
  336.                   return false;
  337.                }
  338.  
  339.                if (var2 instanceof Window) {
  340.                   break;
  341.                }
  342.             }
  343.          }
  344.  
  345.          return true;
  346.       } else {
  347.          return false;
  348.       }
  349.    }
  350. }
  351.